/----------------------------------------------------------------------------\
|-[ 04 ]----[ Curso de C y C++ IV ]----[ Bajo ]------------------------------|
\-----------------------------------------------------------------[ IReick ]-/


7-FUNCIONES


7.1 FUNCIONES

La tecnica de la programacion estructurada consiste en dividir el programa 
en varios bloques independientes que puedan ejecutarse desde cualquier punto 
del programa. Asi evitamos tener que repetir el cdigo en varias partes del 
programa en la que se realiza la misma tarea.
Estos fragmentos de programa las conocemos con el nombre de funciones.
Lo primero que debemos hacer es definir las funciones, indicando paso por 
paso todo lo que deben hacer.
Las funciones puden definirse en cualquier parte del programa.
Con Turbo C tenemos dos formatos diferentes para la definicion de funciones, 
el clasico y el moderno:
-Segun el metodo clasico:

	tipo nombrefuncion(parametro,parametro...)
		tipo	parametro;
		tipo	parametro;
		{
		declaraciones;
		sentencias;
		}

-Segun el metodo moderno:

	tipo nombrefuncion(tipo parametro,tipo parametro...)
		{
		declaraciones;
		sentencias;
		}

Estos formatos son muy flexibles, ya que no todas las funciones deben llevar 
parametros ni declaraciones.
Lo que siempre sera necesario es indicar el nombre de la funcion,seguido de 
los parentesis y el cuerpo de la funcion.
Turbo C no nos permite definir una funcion dentro de otra.
Dividiremos el estudio de las funciones en tres grupos:
1-Funciones que no reciben ni devuelven datos.
2-Funciones que no reciben datos, pero si los devuelven.
3-Funciones que reciben y devuelven datos.


7.2 FUNCIONES VOID

Se definen como tipo VOID aquellas funciones que no devuelven ningun valor.
Las funcione smas sencillas son aquellas que ni reciben ningun parametro ni 
devuelven ningun valor.
Estas tienen el siguiente formato:

	void nombrefuncion()
		{
		sentencias;
		}

Es posible que dentro de una funcion de tipo void necesitemos utilizar una 
variable. Entonces la declararemos al principio del cuerpo de la funcion. 
Estas se conocen como variables locales y solo podran utilizarse dentro de 
la funcion en la que esten declaradas.


7.3 RETURN

Algunas funciones no reciben ningun parametro, pero devuelven un valor.
Al definir este tipo de funciones, en la linea de la cabecera indicamos el 
tipo de valor que devuelve (int, char...)
Return es la orden que nos permite devolver un valor a la funcion principal 
y su formato es:

	return(variable);

Al ejecutar una funcion de este tipo desde el cuerpo principal del programa, 
se devolvera el contenido de la variable situada entre parentesis en la 
instruccion return.
En estas funciones sera imprescindible declarar, al menos, la variable que 
va a devolver.
Cuando el tipo de la funcion no coincide con el tipo de la variable que se 
devuelve, Turbo C convertir el valor de la variable al tipo especificado en 
la funcion.
Es posible que una funcion deba devolver diferentes valore,s dependiendo de 
una condicion. En estos casos, podran utilizarse tantas sentencias return 
como se necesiten.


7.4 FUNCIONES CON PARAMETROS

A veces una funcion debe operar con unos datos que se le deben proporcionar 
desde el programa principal. Estos datos reciben el nombre de parametros, 
los cuales hemos de declarar en el encabezamiento de la funcion. Para esto 
tenemos dos metodos, clasico y moderno:
-Clasico

	tipo nombrefuncion(parametro,parametro...)
		tipo	parametro;
		tipo	parametro;
		...

-Moderno

	tipo nombrefuncion(tipo parametro, tipo parametro...)

Al ejecutar una funcion que lleva parametros desde el cuerpo principal del 
programa habra que indicar los valores que deberan tener dichos parametros. 
Con esos valores que se le indiquen sera con los que trabaje la funcion.
Una funcion podra llevar tantos parametros como se necesiten, y no todos 
tienen por que ser del mismo tipo.
Cuando una funcion deba devolver un valor diferente, dependiendo de uno de 
sus parametros, antes de ejecutar la funcion desde el programa principal, 
habra que asegurarse de que el dato asignado a ese parametro contiene un 
valor adecuado.


7.5 LLAMADAS A FUNCIONES

El hecho de ejecutar una funcion desde el cuerpo principal del programa, se 
conoce como llamar a la funcion.
Para llamar a una funcion de tipo void, bastara con teclear su nombre, 
seguido de los parentesis y finalizando en punto y coma. Ejemplo:

	llamadafuncion();

Esto llamara a la funcion llamadafuncion.
Cuando la funcion devuelve un valor, debera utilizarse una sentencia de 
asignacion, que introduzca en uan variable el valor devuelto por la funcion. 
El formato de este tipo de llamadas es:

	variable=funcion();

La variable debe ser del mismo tipo del valor que devuelve la funcion.
En estos casos el valor de la variable de la instruccion return se 
almacenara en la variable a la que se asigne la funcion.
Cuando la funcion lleve parametros, habra que indicarlos entre parentesis. 
Habra que poner tantas variables como parametros tenga la funcion, teniendo 
en cuenta que deben ser del mismo tipo y deben estar colocados en el mismo 
orden. Ejemplo:

	llamada=funcion(dato1,dato2);

Donde dato1 y dato2 han estado declarados previamente y tienen ya algun 
valor.
Debemos tener cuidado con las llamadas a estas funciones, ya que si se 
introducen mas o menos parametros de los indicados en el encabezamiento de 
la funcion, o sus tipos no coinciden se producira un error.

EJEMPLOS

--------CORTA AQUI---------

void repre()
	{
	clrscr();
	gotoxy(10,5);printf("1.Obtener mayor");
	gotoxy(10,7);printf("2.Obtener menor");
	gotoxy(10,9);printf("3.Obtener diferencia");
	gotoxy(10,11);printf("4.Fin");
	gotoxy(10,13);printf("Seleccione una opcion: ");
	}

void pulsa()
	{
	char	tecla;

	gotoxy(10,13);pritnf("pulsa la barra espaciadora");
	while((tecla=getch())!=' ')
		;
	}

int num1()
	{
	int	a;

	clrscr();
	gotoxy(10,5);printf("Introduzca dos numeros diferentes: ");
	gotoxy(10,7);printf("Primer numero: ")
	scanf("%d",&a);
	return(a);
	}

int num2()
	{
	int	a;

	gotoxy(10,9);printf("segundo numero: ");
	scanf("%d",&a);
	return(a);
	}

int mayor(int a, int b)
	{
	if (a>b)
		return(a);
	else
		return(b);
	}

int menor(int a, int b)
	{
	if (a<b)
		return(a);
	else
		return(b);
	}

main()
{
	int opcion, dato1, dato2, diferencia, mas, menos;
	do
		{
		do
			{
			repre();
			scanf("%d",&opcion);
			}
		while (opcion>4);
		if (opcion==1)
			{
			do
				{
				dato1=num1();
				dato2=num2();
				}
			while (dato1==dato2);
			mas=mayor(dato1,dato2);
			gotoxy(10,11);printf("El numero mayor es %d",mas);
			pulsa();
			}
		if (opcion==1)
			{
			do
				{
				dato1=num1();
				dato2=num2();
				}
			while (dato1==dato2);
			menos=menor(dato1,dato2);
			gotoxy(10,11);printf("El numero menor es %d",mas);
			pulsa();
			}
		else if (opcion==3)
			{
			do
				{
				dato1=num1();
				dato2=num2();
				}
			while (dato1==dato2);
			mas=mayor(dato1,dato2);
			menos=menor(dato1,dato2);
			diferencia=mas-menos;
			gotoxy(10,11);printf("La diferencia es %d",diferencia);
			pulsa();
			}
		}
	while (opcion!=4);
	clrscr();
	gotoxy(10,10);printf("fin del programa");
}
--------CORTAR AQUI-----




8-BIFURCACIONES INCONDICIONALES


8.1 GOTO

La instruccion goto es una instruccion de bifurcaicon incondicional, es 
decir, hace que la ejecucion del programa salte de una instruccion a otra 
diferente, que no le sigue en la secuencia normal de ejeucion.
Su formato es:

	goto etiqueta;

Donde etiqueta es un identificador, asignado a una determinada instruccion 
del programa. Al ejecutarse esta orden se saltaran todas las sentencias 
comprendidas entre goto y la etiqueta, y el programa continuara por esta 
ultima.
Para poner una etiqueta en una determinada instruccion hay que escribir su 
nombre, seguido de dos puntos, antes de la instruccion adecuada.


8.2 BREAK

La instruccion break es tambien una instruccion de bifurcacion que provoca 
una ruptura en el bucle que la contiene.
Esta instruccion solo podra utilizarse en instrucciones que generen bucles 
como for, while o do-while.
Su formato es:

	break;
Cuando dentro de un bucle se ejecuta una instruccion break, la ejecucion de 
ese bucle finaliza y el programa continua por la instruccion inmediatamente 
siguiente al bucle.
Cuando se tienen varios bucles, anidados unos dentro de otros, la 
instruccion break hara que deje de ejecutarse el bucle en el que este 
ocmprendida pero no afectara a los bucles superiores a el.

EJEMPLO

--------CORTAR AQUI
int eleva(int a, int b);
	{
	int	cont,result;

	for(cont=1,result=a;cont<b;cont++)
		result=result*a;
	return(result);
	}

main()
{
	int	num,ele,res;

	clrscr();
	while(1)
	{
	printf("un numero: ");scanf("%d",&numero);
	if (num==0)
		break;
	printf("elevado a: ");scanf("%d",&ele);
	res=eleva(num,ele);
	printf("\t %d elevado a %d = %d\N";num,ele,res);
	}
	printf("\n\nfin del programa");
}
-------------CORTA AQUI


8.3 CONTINUE

La instruccion continue sirve para alterar la ejecucion de un bucle, por lo 
que solo podra utilizarse con las intrucciones for, do-while, while.
Su formato es:

	continue;

Cuando se ejecute la instruccion cotinue, se saltara todas las instrucciones 
que hayan por detras, pasando de nuevo a evaluar la condicion del bucle, isn 
ejecutar las lineas posteriores. Es decir, esta orden vuelve a repetir la 
misma vuelta de bucle, siempre y cuando la sentencia que modifica la 
variable contador este detras de continue.
Ahi que tener en cuenta que en los bucles for, la orden continue hara que el 
programa vuelva a evaluar la segunda expresion de la instruccion, sin haber 
evaluado la tercera, por lo tanto, si la modificacion de la variable no la 
realiza en el bucle, sino en la tercera expresion de la cabecera del for, la 
instruccion continue siempre hara que se repita la misma vuelta.

EJEMPLO

-------CORTA AQUI
main()
{
	float	num,tot,cont,media;

	cont=tot=0;
	clrscr();
	while(1)
		{
		printf("introduce un numero para fin: ");
		scanf("%f",&num);
		if (num==0)
			break;
		if (num<0)
			continue;
		cont++;
		tot=tot + num;
		printf("total=%.2F\n",tot);
		}
	media=tot/cont;
	printf("\n\nmedia=.2F%",media);
}
-------CORTA AQUI


8.4 SWITCH

Switch es una instruccion de seleccion que permite efectuar un salto directo 
a una determinada sentencia, dependiendo del valor de una variable o 
expresion.
Su formato es:

	switch(valor) {
	case a: sentencia;
		break;
	case b: sentencia;
		break;
	...
	default:sentencia;
	}

La instruccion switch nos sireve cuando dependiendo del valor de una 
variable debe ejecutarse una sentencia u otra.
Tras ejecutar la sentencia, y encontrandose con la instruccion break, el 
programa saldra del bucle y continuara ejecutandose por la siguiente linea.
Si el valor de la variable no coincide con ninguno de los indicados en los 
case, se ejecutara la sentencia que acompaa a la etiqueta default.
El dato que va entre parntesis, en funcion del cual se saltara a una u otra 
etiqueta case, podra ser una variable o una expresion de tipo int o char.
Los datos que acompaan a las etiquetas case deberan ser constantes. En 
ningun caso podran indicarse variables o expresiones.
La instruccion switch nos permite que una sentencie lleve varias etiquetas 
case. En este caso, dicha sentencia se ejecutara cuando el valor de la 
variableo expresion coincida con alguno de los indicados en las etiquetas.

EJEMPLO

---------CORTA AQUI
main()
{
int num;
char tecla;

while(1)
	{
	clrscr();
	gotoxy(10,5);pritnf("Introduce un numero del 1 al 5");
	gotoxy(10,7);pritnf("para terminar introduce el 0: ");
	scanf("%d",&num);
	if(num==0);
		break;
	gotoxy(10,9);
	switch(num){
	case 1: printf("un");
		break;
	case 2: printf("dos");
		break;
	case 3: printf("tres");
		break;
	case 4:
	case 5: printf("no se como se dice");
		break;
	default: printf("Te dije del 1 al 5");
	}
	gotoxy(10,11);printf("pulsa la barra espaciadora");
	while ((tecla=getch())!=' ')
		;
	}
clrscr()
}
-------CORTAR AQUI


*EOF*
